

//建造者模式--Builder模式
// 将一个复杂对象的构造与它的表示分离，使同样的构建过程可以
// 创建不同的表示，这样的设计模式被称为建造者模式

// 该模式的主要优点如下：
// 封装性好，构建和表示分离。
// 扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
// 客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。

// 其缺点如下：
// 产品的组成部分必须相同，这限制了其使用范围。
// 如果产品的内部变化复杂，如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大。

public class ParlourDecorator{
	public static void main(String [] args){
		Builder builder = new ConcreteBuilder();
		Director director = new Director(builder);
		Product product = director.construct();
		product.show();
		System.out.println("hello world");
	}
}

//产品：包含多个组件的复杂对象
class Product{
	private String partA;
	private String partB;
	private String partC;
	public void setPartA(String partA){
		this.partA=partA;
	}

	public void setPartB(String partB){
		this.partB=partB;
	}

	public void setPartC(String partC){
		this.partC=partC;
	}

	public void show(){
		System.out.println(partA+partB+partC);
	}
}

//抽象建造者：包含创建各个子部件的抽象方法
abstract class Builder{
	protected Product product = new Product();
	public abstract void buildPartA();
	public abstract void buildPartB();
	public abstract void buildPartC();

	public Product getResult(){
		return product;
	}
}

//具体建造者：实现抽象接口
class ConcreteBuilder extends Builder {
	public void buildPartA(){
		product.setPartA("建造partA");
	}

	public void buildPartB(){
		product.setPartB("建造partB");
	}

	public void buildPartC(){
		product.setPartC("建造partC");
	}
}

//指挥者：调用建造者完成创建
class Director{
	private Builder builder;
	public Director(Builder builder){
		this.builder=builder;
	}

	public Product construct(){
		builder.buildPartA();
		builder.buildPartB();
		builder.buildPartC();
		return builder.getResult();
	}
}